add new abstract type for iterators with HasShape: ShapefulIterator
#58052
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
nsajko
commented
Apr 9, 2025
| ndims(c::AbstractChar) = 0 | ||
| ndims(::Type{<:AbstractChar}) = 0 | ||
| length(c::AbstractChar) = 1 | ||
| IteratorSize(::Type{Char}) = HasShape{0}() |
Member
Author
There was a problem hiding this comment.
NB: here IteratorSize was defined for Char. With this PR it's defined for all AbstractChar subtypes (making this kinda a minor change). However that's OK, because this method should have been IteratorSize(::Type{AbstractChar}) = HasShape{0}() in the first place. Refer to:
Member
Author
There was a problem hiding this comment.
ndims being defined for AbstractChar implies IteratorSize should be treated the same, I'd say.
nsajko
force-pushed
the
new_abstract_type_ShapefulIterator
branch
2 times, most recently
from
5754426 to
c4e8f44
Compare
Member
Author
|
Notes:
|
Member
Author
|
An interesting consequence of this PR is that julia> typeof([3, [7]])
Vector{ShapefulIterator} (alias for Array{ShapefulIterator, 1}) |
nsajko
added
the
needs pkgeval
Iterators with `HasShape{N}` are certainly the most well-behaved class
of iterators in Julia. Currently several separate type trees of such
iterators come with Julia. It seems like joining these trees under a
single abstract type would be nice.
Why this change is useful:
* Make expressing hardcoded `Union` types for zero-dimensional
collections unnecessary: instead of
`Union{Number,Ref,AbstractArray{<:Any,0}}` now it will be possible to
write simply, and more generically, `ShapefulIterator{0}`. At
least in some cases.
* Reduce the number of `ndims` and `IteratorSize` methods:
* The number of `ndims` methods that come with Julia is
decreased by six
* The number of `IteratorSize` methods that come with Julia is
decreased by three
Why this change doesn't prevent a better future supertype choice:
* Naively it might make sense to have `Number`, `AbstractChar` and
`Ref` subtype a parameterless abstract type like
`ZeroDimensionalIterator`. However:
* This seems less useful than `ShapefulIterator{N}`
* Adding `ShapefulIterator` doesn't preclude adding
`ZeroDimensionalIterator <: ShapefulIterator{0}` later.
* One might ask: why not make `AbstractArray{T}` subtype a different
abstract type, with an element type type parameter, something like
`AbstractArray{T,N} <: TypedIterator{T}`. In this case, however,
`TypedIterator` would be useless for the zero dimensional iterators
mentioned above, as they are their own element types, something not
expressible in abstract type subtyping.
nsajko
force-pushed
the
new_abstract_type_ShapefulIterator
branch
from
c4e8f44 to
70c2516
Compare
nsajko
added
the
speculative
Member
Author
|
Giving up on this, at least for now, as I have too many open PRs to handle. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Iterators with
HasShape{N}are certainly the most well-behaved class of iterators in Julia. Currently several separate type trees of such iterators come with Julia. It seems like joining these trees under a single abstract type would be nice.Why this change is useful:
Uniontypes for zero-dimensional collections unnecessary: instead ofUnion{Number,Ref,AbstractArray{<:Any,0}}now it will be possible to write simply, and more generically,ShapefulIterator{0}. At least in some cases.ndimsandIteratorSizemethods:ndimsmethods that come with Julia is decreased by sixIteratorSizemethods that come with Julia is decreased by threeWhy this change doesn't prevent a better future supertype choice:
Number,AbstractCharandRefsubtype a parameterless abstract type likeZeroDimensionalIterator. However:ShapefulIterator{N}ShapefulIteratordoesn't preclude addingZeroDimensionalIterator <: ShapefulIterator{0}later.AbstractArray{T}subtype a different abstract type, with an element type type parameter, something likeAbstractArray{T,N} <: TypedIterator{T}. In this case, however,TypedIteratorwould be useless for the zero dimensional iterators mentioned above, as they are their own element types, something not expressible in abstract type subtyping.